#!/bin/bash

###########################################
#           Script de instalacion         #
#                                         #
# TP Sistemas Operativos - 1er Cuat. 2012 #
###########################################

grupo="grupo01"
actual=$PWD
CONFDIR="confdir/"

###########################################
# paquetes a instalar en el sistema 
###########################################

# nombre de los ejecutables
NOMBRE_IniciarT="IniciarT.sh"
NOMBRE_DetectarT="DetectarT.sh"
NOMBRE_GrabarParqueT="GrabarParqueT.sh"
NOMBRE_ListarT="ListarT.pl"
NOMBRE_MoverT="MoverT.sh"
NOMBRE_LoguearT="LoguearT.pl"
NOMBRE_MirarT="MirarT.pl"
NOMBRE_StopD="StopD.sh"
NOMBRE_StartD="StartD.sh"
NOMBRE_ValidarFecha="ValidarFecha.sh"
NOMBRE_ValidarFechaFormato="ValidarFechaFormato.sh"
NOMBRE_CargarMensajes="CargarMensajes.sh"

# indices de los vectores de datos
IniciarT=1
DetectarT=2
GrabarParqueT=3
ListarT=4
MoverT=5
LoguearT=6
MirarT=7
StopD=8
StartD=9
ValidarFecha=10
ValidarFechaFormato=11
CargarMensajes=12

# indica si el paquete se debe instalar (0) o si ya fue instalado (1)
paquetes[$IniciarT]=0
paquetes[$DetectarT]=0
paquetes[$GrabarParqueT]=0
paquetes[$ListarT]=0
paquetes[$MoverT]=0
paquetes[$LoguearT]=0
paquetes[$MirarT]=0
paquetes[$StopD]=0
paquetes[$StartD]=0
paquetes[$ValidarFecha]=0
paquetes[$ValidarFechaFormato]=0
paquetes[$CargarMensajes]=0

###########################################################
# Valores por defecto que luego el usuario 
# ingresara en la instalacion 
###########################################################
# indices de los arrays
ARRIDIR=1
DATASIZE=2
RECHDIR=3
BINDIR=4
MAEDIR=5
LOGDIR=6
LOGEXT=7
LOGSIZE=8
REPODIR=9

# vector con los valores por defecto, que luego se iran reemplazando por
# los valores ingresados por el usuario o por valores de alguna configuracion existente
config[$ARRIDIR]="arribos/" # ARRIDIR: directorio de arribo de archivos externos
config[$DATASIZE]=100 # DATASIZE: espacio minimos en directorio ARRIDIR (en MB)
config[$RECHDIR]="rechazados/" # RECHDIR: directorio para los archivos rechazados
config[$BINDIR]="bin/" # BINDIR: directorio de los ejecutables
config[$MAEDIR]="maedir/" # MAEDIR: directorio de los archivos maestros
config[$LOGDIR]="log/" # LOGDIR: directorio de los logs de auditoria
config[$LOGEXT]=".log" # LOGEXT: extension para los archivos de log
config[$LOGSIZE]=400 # LOGSIZE: tamanio maximo de los archivos de log (en KB)
config[$REPODIR]="reportes/" # REPODIR: directorio de los reportes de salida

# flag que me indica si ya hay que leer la configurcion o no de cada valor
config_inst[$ARRIDIR]=0
config_inst[$DATASIZE]=0
config_inst[$RECHDIR]=0
config_inst[$BINDIR]=0
config_inst[$MAEDIR]=0
config_inst[$LOGDIR]=0
config_inst[$LOGEXT]=0
config_inst[$LOGSIZE]=0
config_inst[$REPODIR]=0

# Inicia el archivo de log, si ya existe uno lo renombra poniendole al 
# final el timestamp de la fecha actual
function iniciarLogger {
	chmod +x "inst/bin/${NOMBRE_LoguearT}"
	if [ -f "{$CONFDIR}InstalarT.log" ]
	then
		timestamp=`date +"%d-%m-%Y %T"`
		rm -f "inst/tmp/InstalarT.log"
		#mv "$actual/${config[$LOGDIR]}InstalarT.${config[LOGEXT]}" "$actual/${config[$LOGDIR]}instalarT.${config[LOGEXT]}.$timestamp"
	fi
}

# muestra un mensaje por pantalla y/o lo loguea dependiendo el valor del 
# parametro $3
# $1 = tipo de msj
# $2 = msj
function mostrarMensaje {
	if [ "$3" = "--nolog" ]
	then
		# solo muestro el msj, no lo logueo
		echo -ne "$2"
	elif [ "$3" = "--noshow" ]
	then
		# solo logueo el mensaje, no lo muestro
		if [ -f "./inst/bin/LoguearT.pl" ]
		then
			./inst/bin/LoguearT.pl "InstalarT" "$1" "$2" "InstalarT"
		fi
	else
		# logueo y muestro el msj
		echo -ne "$2"
		if [ -f "./inst/bin/LoguearT.pl" ]
		then
			./inst/bin/LoguearT.pl "InstalarT" "$1" "$2" "InstalarT"
		fi
		#./inst/bin/LoguearT.pl "InstalarT" "$1" "$2" "InstalarT"
	fi
}

# Pide un valor por la entrada standard y loguea el mensaje con el 
# valor ingresado
# $1 = tipo de msj
# $2 = msj
function pedirValor {
	mostrarMensaje "I" "$2" --nolog
	read lectura
	mostrarMensaje "I" "$2 $lectura\n" --noshow
}

# copia el archivo ejecutable pasado por parametro
function moverEjecutable {
	if [ ${paquetes[$1]} -eq 0 ]
	then
		cp -f "inst/bin/$2" "${config[$BINDIR]}"
		chmod +x "${config[$BINDIR]}$2"
	fi
}

# mueve todos los archivos maestros 
function moverMaestros {
	if [ -f "inst/mae/sucu.mae" ]
	then
		cp "inst/mae/sucu.mae" "$1"
		chmod 0775 "${1}sucu.mae"
	else
		mostrarMensaje "E" "No existe el archivo sucu.mae"
		exit 1
	fi
	
	if [ -f "inst/mae/cli.mae" ]
	then
		cp "inst/mae/cli.mae" "$1"
		chmod 0775 "${1}cli.mae"
	else
		mostrarMensaje "E" "No existe el archivo cli.mae"
		exit 1
	fi
	
	if [ -f "inst/mae/prod.mae" ]
	then
		cp "inst/mae/prod.mae" "$1"
		chmod 0775 "${1}prod.mae"
	else
		mostrarMensaje "E" "No existe el archivo prod.mae"
		exit 1
	fi
	
}

function crearDirectorio {
	mkdir -m 775 -p "$1"
}


# $1 = nombre de la variable
# $2 = indice de la variable
# $3 = mensaje a mostrar
function leerDirectorio {
	
	pedirValor "I" "- $3"
	if [ -n "$lectura" ]
	then
		filtrarDirectorio
		
		while validarDirectorio "$lectura"
		do
			pedirValor "I" "\tEl valor ingresado es incorrecto, ingrese otro:  $lectura"
		done
		
		if [ -n "$lectura" ]
		then
			config[$2]="$lectura"
			guardarConfiguracionTMP "$1" "$lectura"
			mostrarMensaje "I" "- $3 $lectura" "--noshow"
			lectura=""
		else
			guardarConfiguracionTMP "$1" "${config[$2]}"
			mostrarMensaje "I" "- $3 ${config[$2]}" "--noshow"
			lectura=""
		fi
		
	else
		guardarConfiguracionTMP "$1" "${config[$2]}"
		mostrarMensaje "I" "- $3 ${config[$2]}" "--noshow"
		lectura=""
	fi
}

function mostrarDirectorio {
	str=""
	if [ -d "$1" ]
	then
		for file in $(ls -l "$1")
		do
			if [ -f "${1}/${file}" ]
			then
				str="${str}\t -> $file\n"
			fi
		done
	fi
	echo -ne "$str"
}

function obtenerEspaciolibre {
	i=0
	matcheo=""
	for pto in $(df -P | tail -n +2 | awk '{print $6}')
	do
		res=$(echo $PWD | grep "^$pto")
		if [ "$res" = "$PWD" ]
		then
			if [ ${#matcheo} -le ${#pto} ]
			then
				matcheo="$pto"
			fi
		fi
	done

	a=$(df -P | grep "$matcheo$" | awk '{print $4}')
	let a=a/1024
	espacio_disponible=$a
}

function mostrarDatos {
	confdir_str=$(mostrarDirectorio "$CONFDIR")
	bindir_str=$(mostrarDirectorio "${config[$BINDIR]}")
	maedir_str=$(mostrarDirectorio "${config[$MAEDIR]}")
	
	mensaje="* Libreria del sistema: $CONFDIR
${confdir_str}
* Directorio de archivos externos: ${config[$ARRIDIR]}
* Espacio minimo para archivos externos: ${config[$DATASIZE]} MB
* Directorio de grabacion de archivos rechazados: ${config[$RECHDIR]}
* Instalacion de ejecutables: ${config[$BINDIR]}
${bindir_str}
* Directorio instalacion de archivos maestros: ${config[$MAEDIR]}
${maedir_str}
* Directorio de logs de auditoria: ${config[$LOGDIR]}
* Extension de archivos de logs: ${config[$LOGEXT]}
* Tamanio maximo para archivos de logs: ${config[$LOGSIZE]} KB
* Directorio reportes de salida: ${config[$REPODIR]}"

	mostrarMensaje "I" "$mensaje"
}

function filtrarDirectorio {
	# si comienza con / se la borro
	lectura=${lectura#/}
	# si comienza con ./ se la borro
	lectura=${lectura#./}
	# si termina en / se la borro
	lectura=${lectura%/}
	# el directorio es relativo a la posicion actual del instalador
	# si el directorio ingresado comienza con '.' lo borro
	#lectura=`echo $lectura | sed "s/^\.\(.*\)/\1/"`
	# si despues del punto habia una barra la borro tambien
	#lectura=`echo $lectura | sed "s/^\/\(.*\)/\1/"`
	
	# concateno pwd con el path ingresado
	#lectura="$PWD/$lectura/"
	lectura="$lectura/"
	
}

function validarDirectorio {
	ext=$(echo "$1" | grep "^[a-zA-Z1-9\_\/\ \-]*$")
	if [ "$ext" = "$1" ]
	then
		return 1
	else
		return 0
	fi
}

function validarExtension {
	input="$1"
	if [ "${input:0:1}" != "." ]
	then
		input=".${input}"
	fi
	
	ext=$(echo "$input" | grep "^.[a-zA-Z1-9]*$")
	if [ "$ext" = "$input" ]
	then
		return 1
	else
		return 0
	fi
}

function validarNumero {
	
	out=$(echo "$1" | grep "^[0-9]*$")
	if [ "$out" = "$1" ]
	then
		return 1
	else
		return 0
	fi
}

function verificarMaestrosInst {
	#echo -e "\n\n\n$1\n\n"
	if [ -f "$1" ]
	then
		#echo "\n\nHOLA\n\n"
		let cont_maestros_inst++
	fi
}

function verificarDirectoriosCreados {
	if [ -d "$1"  ]
	then
		let cont_directorios_creados++
	fi
}

function verificarComandosInst {
	if [ -f "$1" ]
	then
		owner=`stat -c %U "$1"`
		fecha=`stat -c %y "$1"`
		fecha="${fecha%%.*}"
		instalados="$instalados\n\t* $2  $fecha $owner"
		paquetes[$3]=1
		config_inst[$BINDIR]=1
		let cont_instalados++
	else
		noinstalados="$noinstalados\n\t* $2"
		let cont_noinstalados++
	fi
}

function obtenerConfPrevia {
	if [ -f "${CONFDIR}InstalarT.conf" ]
	then
		output=$(grep "$2" ${CONFDIR}InstalarT.conf | awk -F "=" '{print $2}')
		if [ -n "$output" ]
		then
			config_inst[$1]=1
			conf_previa="$conf_previa\n\t* $3: '$output'"
			if [ "$4" == "dir" ]
			then
				output=${output:${#actual}} # le borro actual
				output=${output:1} # le borro la primer /
			fi
			config[$1]="$output"
			let cont_conf_previa++
		fi
	else
		if [ -f "./inst/tmp/InstalarT.conf.tmp" ]
		then
			output=$(grep "$2" ./inst/tmp/InstalarT.conf.tmp | awk -F "=" '{print $2}')
			if [ -n "$output" ]
			then
				config_inst[$1]=1
				conf_previa="$conf_previa\n\t* $3: '$output'"
				config[$1]="$output"
				let cont_conf_previa++
			fi
		fi
	fi
}

function guardarConfiguracionTMP {
	if [ -f "./inst/tmp/InstalarT.conf.tmp" ]
	then
		echo "$1=$2" >> "./inst/tmp/InstalarT.conf.tmp"
	else
		touch "./inst/tmp/InstalarT.conf.tmp"
		#./getDate.sh >> "${CONFDIR}instalarT.conf.tmp"
		echo "$1=$2" >> "./inst/tmp/InstalarT.conf.tmp"
	fi
}

function imprimirPasosPendientes {
	mensaje=""
	
	if [ ${config_inst[$ARRIDIR]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el directorio de arribo de archivos 	externos.\n"
	fi
	
	if [ ${config_inst[$DATASIZE]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el espacio minimo libre para el arribo de archivos externos\n"
	fi
	
	if [ ${config_inst[$RECHDIR]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el directorio de grabacion de los archivos externos rechazados\n"
	fi
	
	if [ ${config_inst[$BINDIR]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el directorio de instalacion de los ejecutables\n"
	fi
	
	if [ ${config_inst[$MAEDIR]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el directorio de instalacion de los archivos maestros\n"
	fi
	
	if [ ${config_inst[$LOGDIR]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el directorio de grabacion de los logs de auditoria\n"
	fi
	
	if [ ${config_inst[$LOGEXT]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir la extension para los archivos de log\n"
	fi
	
	if [ ${config_inst[$LOGSIZE]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el tamano maximo para los archivos de log\n"
	fi
	
	if [ ${config_inst[$REPODIR]} -eq 0 ]
	then
		mensaje="${mensaje}\t- Definir el directorio de grabacion de los reportes de salida\n\n"
	fi
	
	if [ "$mensaje" != "" ]
	then
		mensaje="Para completar la instalacion Ud. deberá:\n${mensaje}"
		mostrarMensaje "I" "$mensaje"
	fi
	
	mensaje=""
	if [ $cont_noinstalados -gt 0 ]
	then
		mensaje="${mensaje}\t- Instalar los ejecutables faltantes\n"
	fi
	
	if [ $cont_directorios_creados -lt 5 ]
	then
		mensaje="${mensaje}\t- Crear directorios de sistema\n"
	fi
	
	if [ $cont_maestros_inst -lt 3 ]
	then
		mensaje="${mensaje}\t- Instalar archivos maestros faltantes\n\n"
	fi
	
	if [ "$mensaje" != "" ]
	then
		mensaje="Para completar la instalacion el instalador deberá:\n${mensaje}"
		mostrarMensaje "I" "$mensaje"
	fi
	
}

########################################################################
################# inicia el script de instalacion ######################
########################################################################
clear

iniciarLogger

# chequeo que este la carpeta CONFDIR, sino la creo
if ! [ -d "$CONFDIR" ]
then
	crearDirectorio "$CONFDIR"
fi

mostrarMensaje "I" "Comando InstalarT Inicio de ejecucion...\n\n\n"
mostrarMensaje "I" "TP Sistemas Operativos(75.08) - 1er Cuat. 2012 - Tema T - Grupo 01\n\n"

# checkeo que la instalacion se realice en el directorio correspondiente
if [ "${actual##*/}" != "$grupo" ]
then
    mostrarMensaje "SE" "La instalacion se esta ejecutando en un directorio invalido, debe ejecutarse en $grupo\n"
    exit 1
fi

#############################################################
# chequeo si hay alguna configuracion previa de una 
# instalacion inconclusa
#############################################################
conf_previa=""
cont_conf_previa=0

if [[ -f "./inst/tmp/InstalarT.conf.tmp" || -f "${CONFDIR}InstalarT.conf" ]]
then
	obtenerConfPrevia $ARRIDIR "ARRIDIR" "Arribo de archivos externos" dir
	obtenerConfPrevia $DATASIZE "DATASIZE" "Espacio minimo para archivos externos (MBytes)" size
	obtenerConfPrevia $RECHDIR "RECHDIR" "Directorio de archivos rechazados" dir
	obtenerConfPrevia $BINDIR "BINDIR" "Directorio de ejecutables" dir
	obtenerConfPrevia $MAEDIR "MAEDIR" "Directorio de archivos maestros" dir
	obtenerConfPrevia $LOGDIR "LOGDIR" "Directorio de logs de auditoria" dir
	obtenerConfPrevia $LOGEXT "LOGEXT" "Extension de archivos de logs" ext 
	obtenerConfPrevia $LOGSIZE "LOGSIZE" "Tamano maximo para los archivos de log (KBytes)" size
	obtenerConfPrevia $REPODIR "REPODIR" "Directorio para los reportes de salida" dir
fi


if [ $cont_conf_previa -gt 0 ]
then
	mostrarMensaje "I" "- Configuracion existente:$conf_previa\n"
fi


#############################################################
# Chequeo que paquetes estan instalados y cuales no
#############################################################
instalados=""
noinstalados=""
cont_instalados=0
cont_noinstalados=0

verificarComandosInst "${config[$BINDIR]}${NOMBRE_IniciarT}" "IniciarT" $IniciarT
verificarComandosInst "${config[BINDIR]}${NOMBRE_DetectarT}" "DetectarT" $DetectarT
verificarComandosInst "${config[BINDIR]}${NOMBRE_GrabarParqueT}" "GrabarParqueT" $GrabarParqueT
verificarComandosInst "${config[BINDIR]}${NOMBRE_ListarT}" "ListarT" $ListarT
verificarComandosInst "${config[BINDIR]}${NOMBRE_MoverT}" "MoverT" $MoverT
verificarComandosInst "${config[BINDIR]}${NOMBRE_LoguearT}" "LoguearT" $LoguearT
verificarComandosInst "${config[BINDIR]}${NOMBRE_MirarT}" "MirarT" $MirarT
verificarComandosInst "${config[BINDIR]}${NOMBRE_StopD}" "StopD" $StopD
verificarComandosInst "${config[BINDIR]}${NOMBRE_StartD}" "StartD" $StartD
verificarComandosInst "${config[BINDIR]}${NOMBRE_ValidarFecha}" "ValidarFecha" $ValidarFecha
verificarComandosInst "${config[BINDIR]}${NOMBRE_ValidarFechaFormato}" "ValidarFechaFormato" $ValidarFechaFormato
verificarComandosInst "${config[BINDIR]}${NOMBRE_CargarMensajes}" "CargarMensajes" $CargarMensajes

instalados="- Componentes instalados($cont_instalados):$instalados"
noinstalados="- Componentes faltantes($cont_noinstalados):$noinstalados"

cont_directorios_creados=0
verificarDirectoriosCreados "inst_recibidas"
verificarDirectoriosCreados "inst_ordenadas"
verificarDirectoriosCreados "inst_rechazadas"
verificarDirectoriosCreados "inst_procesadas"
verificarDirectoriosCreados "inst_procesadas"

cont_maestros_inst=0
verificarMaestrosInst "${config[MAEDIR]}cli.mae"
verificarMaestrosInst "${config[MAEDIR]}sucu.mae"
verificarMaestrosInst "${config[MAEDIR]}prod.mae"


if [ $cont_instalados -gt 0 ]
then
	mostrarMensaje "I" "${instalados}\n"
	mostrarMensaje "I" "${noinstalados}\n"
fi

if [[ $cont_noinstalados -eq 0 && $cont_conf_previa -eq 9 && $cont_directorios_creados -eq 5 && $cont_maestros_inst -eq 3 ]]
then
	mostrarDatos
	mostrarMensaje "I" "Estado de la instalacion: COMPLETA.\n\n"
	mostrarMensaje "I" "Proceso de instalacion finalizado\n"
	exit 0
elif [[ $cont_instalados -gt 0 || $cont_conf_previa -gt 0 || $cont_directorios_creados -gt 0 || $cont_maestros_inst -gt 0 ]]
then
	###################################################################
	# se continua una instalacion previa
	###################################################################
	mostrarMensaje "I" "Estado de la instalacion: INCOMPLETA.\n\n"
	
	imprimirPasosPendientes
	
	pedirValor "I" "Desea completar con la instlacion? (S/n): "
	if [[ "$lectura" != "S" && "$lectura" != "s" && -n "$lectura" ]]
	then
		mostrarMensaje "I" "Proceso de instalacion finalizado\n"
		exit 1
	fi
fi


# imprimo info antes de comenzar a pedir el ingreso de datos #######
mostrarMensaje "I" "Directorio de trabajo para la instalacion '$actual'\n"
mostrarMensaje "I" "ACLARACION: Todos los path ingresados en el proceso de instalacion son RELATIVOS a el directorio de trabajo actual!!!\n"
mostrarMensaje "I" "Libreria de sistema: '$CONFDIR'\n\n"

#############################################################
# Checkeo la version de perl 
#############################################################
# borro las lineas vacias
perl_v=`perl -v | head -n 2 | sed -e "s/^\[\]$//"`
# me quedo con la version de perl
perl_v=`echo $perl_v | sed -e "s/^This is perl[^0-9]*\([0-9]\).*/\1/"`

if [ "$perl_v" -lt 5 ]
then
	mostrarMensaje "I" "\n\nPara instalar el TP es necesario contar con Perl 5 o superior instalado.
Efectue su instalacion e intentelo nuevamente.
\n\nProceso de instalacion Cancelado."
	exit 1
else
	mostrarMensaje "I" "\n- Version instalada de Perl: $perl_v\n\n"
fi

datos_incorrectos=1
while [ $datos_incorrectos -eq 1 ]
do
	## Leo directorio de archivos externos #########################
	if [ ${config_inst[$ARRIDIR]} -eq 0 ]
	then
		mensaje="Defina el directorio de arribo de archivos externos (${config[$ARRIDIR]}): "
		leerDirectorio "ARRIDIR" "$ARRIDIR" "$mensaje"
	fi


	## Leo espacio minimo para archivos externos ###################
	if [ ${config_inst[$DATASIZE]} -eq 0 ]
	then
		# en la variable espacio_disponible me pone el espacio disponible en MB
		obtenerEspaciolibre

		pedirValor "I" "- Definia el espacio minimo libre para el arribo de archivos externos en MBytes (${config[$DATASIZE]}): "
		
		if [ -n "$lectura" ]
		then
			while validarNumero "$lectura"
			do
				pedirValor "E" "El valor ingresado no es un numero, ingreselo nuevamente (${config[$DATASIZE]}): "
			done
			if [ -n "$lectura" ]
				then
					lectura="$lectura"
				else
					#guardarConfiguracionTMP "LOGSIZE" "${config[$LOGSIZE]}"
					lectura=${config[$DATASIZE]} #asigno datasize para que salga del while
				fi
			while [ "$espacio_disponible" -lt "$lectura" ]
			do
				mostrarMensaje "E" "Insuficiente espacio en disco.\nEspacio disponible: $espacio_disponible MB.\nEspacio requerido $lectura MB.\n"
				
				pedirValor "I" "Cancele la instalacion e intentelo mas tarde o vuelva a intentarlo con otro valor(${config[$DATASIZE]}): "
				
				while validarNumero "$lectura"
				do
					pedirValor "E" "El valor ingresado no es un numero, ingreselo nuevamente (${config[$DATASIZE]}): "
				done

				#if ! [ -n "$lectura" ]
				#then
				#	lectura=${config[$DATASIZE]} #asigno datasize para que salga del while
				#fi
				
				##
				if [ -n "$lectura" ]
				then
					lectura="$lectura"
				else
					#guardarConfiguracionTMP "LOGSIZE" "${config[$LOGSIZE]}"
					lectura=${config[$DATASIZE]} #asigno datasize para que salga del while
				fi
				###
			done
			
			guardarConfiguracionTMP "DATASIZE" "$lectura"
			config[$DATASIZE]="$lectura"
		else
			guardarConfiguracionTMP "DATASIZE" "${config[$DATASIZE]}"
		fi

		lectura=""
	fi

	## Leo directorio para grabar archivos rechazados ###############
	if [ ${config_inst[$RECHDIR]} -eq 0 ]
	then
		mensaje="Defina el directorio de grabacion de los archivos externos rechazados (${config[$RECHDIR]}): "
		leerDirectorio "RECHDIR" "$RECHDIR" "$mensaje"
	fi


	## Leo directorio de instalacion de los ejecutables ############
	if [ ${config_inst[$BINDIR]} -eq 0 ]
	then
		mensaje="Defina el directorio de instalacion de los ejecutables (${config[$BINDIR]}): "
		leerDirectorio "BINDIR" "$BINDIR" "$mensaje"
	fi


	## Leo directorio de instalacion de los archivos maestros ######
	if [ ${config_inst[$MAEDIR]} -eq 0 ]
	then
		mensaje="Defina el directorio de instalacion de los archivos maestros (${config[$MAEDIR]}): "
		leerDirectorio "MAEDIR" "$MAEDIR" "$mensaje"
	fi
	

	## Leo directorio de grabacion de los logs de auditoria #######
	if [ ${config_inst[$LOGDIR]} -eq 0 ]
	then
		mensaje="Defina el directorio de grabacion de los logs de auditoria (${config[$LOGDIR]}): "
		leerDirectorio "LOGDIR" "$LOGDIR" "$mensaje"
	fi
	
	
	## Leo la extension para los archivos de log ##################
	if [ ${config_inst[$LOGEXT]} -eq 0 ]
	then
		pedirValor "I" "- Defina la extension para los archivos de log (${config[$LOGEXT]}): "
		if [ -z "$lectura" ]
		then
			lectura="${config[$LOGEXT]}"
		fi
		
		if [ "${lectura:0:1}" != "." ]
		then
			lectura=".${lectura}"
		fi
		ct=0
		while validarExtension "$lectura"
		do
			pedirValor "E" "Extension invalida, solo se aceptan caracteres alfanumericos: "
			
			if [ -z "$lectura" ]
			then
				lectura="${config[$LOGEXT]}"
			fi
			if [ "${lectura:0:1}" != "." ]
			then
				lectura=".${lectura}"
			fi
		done
		guardarConfiguracionTMP "LOGEXT" "$lectura"
		config[$LOGEXT]="$lectura"
		lectura=""
	fi


	## Leo leo el tamanio maximo para los archivos de log ########
	let espacio_disponible_kb=espacio_disponible*1024
	if [ ${config_inst[$LOGSIZE]} -eq 0 ]
	then
		pedirValor "I" "- Defina el tamano maximo para los archivos ${config[$LOGEXT]} en KBytes (${config[$LOGSIZE]}): "
		if [ -n "$lectura" ]
		then
			while validarNumero "$lectura"
			do
				pedirValor "E" "El valor ingresado no es un numero, ingreselo nuevamente (${config[$LOGSIZE]}): "
			done
			
			if [ -n "$lectura" ]
				then
					lectura="$lectura"
				else
					#guardarConfiguracionTMP "LOGSIZE" "${config[$LOGSIZE]}"
					lectura=${config[$LOGSIZE]} #asigno datasize para que salga del while
				fi
			while [ "$espacio_disponible_kb" -lt "$lectura" ]
			do
				mostrarMensaje "E" "Insuficiente espacio en disco.\nEspacio disponible: $espacio_disponible_kb KB.\nEspacio requerido $lectura KB.\n"
				
				pedirValor "I" "Cancele la instalacion e intentelo mas tarde o vuelva a intentarlo con otro valor(${config[$LOGSIZE]}): "
				
				while validarNumero "$lectura"
				do
					pedirValor "E" "El valor ingresado no es un numero, ingreselo nuevamente (${config[$LOGSIZE]}): "
				done
				if [ -n "$lectura" ]
				then
					lectura="$lectura"
				else
					lectura=${config[$LOGSIZE]} #asigno LOGSIZE para que salga del while
				fi
			done
			guardarConfiguracionTMP "LOGSIZE" "$lectura"
			config[$LOGSIZE]="$lectura"
				
		else
			guardarConfiguracionTMP "LOGSIZE" "${config[$LOGSIZE]}"
			lectura=""
		fi
	fi


	## Leo el directorio de grabacion de los reportes de salida ##
	if [ ${config_inst[$REPODIR]} -eq 0 ]
	then
		mensaje="Defina el directorio de grabacion de los reportes de salida (${config[$REPODIR]}): "
		leerDirectorio "REPODIR" "$REPODIR" "$mensaje"
	fi

	mostrarDatos

	mostrarMensaje "I" "\nEstado de Instalacion: LISTA\n\n"

	pedirValor "I" "Los datos ingresados son correctos? (S/n): "
	
	if [[ "$lectura" != "S" && "$lectura" != "s" && -n "$lectura" ]]
	then		
		datos_incorrectos=1
		clear
	else
		datos_incorrectos=0
	fi
done

#######################################################################
# Finalizan las preguntas
#######################################################################

# confirmo la instalacion #############################################
pedirValor "I" "Iniciando la instalacion. Esta Ud. seguro? (S/n): "

if [[ "$lectura" != "S" && "$lectura" != "s" && -n "$lectura" ]]
then
	mostrarMensaje "I" "Proceso de instalacion finalizado\n"
	exit 1
fi

# creo estructura de directorios ######################################
mostrarMensaje "I" "\nCreando estructura de directorios....\n"
crearDirectorio "${config[$ARRIDIR]}"
crearDirectorio "${config[$RECHDIR]}"
crearDirectorio "${config[$BINDIR]}"
crearDirectorio "${config[$MAEDIR]}"
crearDirectorio "${config[$LOGDIR]}"
crearDirectorio "${config[$REPODIR]}"
crearDirectorio "inst_recibidas"
crearDirectorio "inst_ordenadas"
crearDirectorio "inst_rechazadas"
crearDirectorio "inst_procesadas"
crearDirectorio "parque_instalado"


# mover archivos maestros a MAEDIR ####
mostrarMensaje "I" "Instalando archivos Maestros\n"
moverMaestros "${config[$MAEDIR]}"

########################################################################
# muevo todos los ejecutables que no esten instalados ##################
########################################################################
mostrarMensaje "I" "Instalando programas y funciones\n"



# muevo IniciarT.sh
moverEjecutable $IniciarT "${NOMBRE_IniciarT}"

# muevo DetectarT.sh
moverEjecutable $DetectarT "${NOMBRE_DetectarT}"

# muevo GrabarParqueT.sh
moverEjecutable $GrabarParqueT "${NOMBRE_GrabarParqueT}"

# muevo ListarT.sh
moverEjecutable $ListarT "${NOMBRE_ListarT}"

# muevo MoverT.sh
moverEjecutable $MoverT "${NOMBRE_MoverT}"



# muevo MirarT.sh
moverEjecutable $MirarT "${NOMBRE_MirarT}"

# muevo StopD.sh
moverEjecutable $StopD "${NOMBRE_StopD}"

# muevo StartD.sh
moverEjecutable $StartD "${NOMBRE_StartD}"

# muevo los comandos adicionales
moverEjecutable $ValidarFechaFormato "ValidarFechaFormato.sh"
moverEjecutable $ValidarFecha "ValidarFecha.sh"

# muevo CargarMensajes.sh
moverEjecutable $CargarMensajes "${NOMBRE_CargarMensajes}"

# actualizar el archivo de configuracion ####
mostrarMensaje "I" "Actualizando la configuracion del sistema\n"

login_user=$(who am i | awk '{print $1}')
date=$(date +"%d-%m-%Y %T")
str="$login_user=$date"

if [ -f "${CONFDIR}InstalarT.conf" ]
then
	
	tail=$(tail -n +21 "${CONFDIR}InstalarT.conf")
	
	# si existe solo actulizo las primereas 10
	echo -e "GRUPO=01=$str" > "${actual}/${CONFDIR}InstalarT.conf" #piso el archivo viejo
	echo -e "ARRIDIR=${actual}/${config[$ARRIDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "DATASIZE=${config[$DATASIZE]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "RECHDIR=${actual}/${config[$RECHDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "BINDIR=${actual}/${config[$BINDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "MAEDIR=${actual}/${config[$MAEDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "LOGDIR=${actual}/${config[$LOGDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "LOGEXT=${config[$LOGEXT]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "LOGSIZE=${config[$LOGSIZE]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "REPODIR=${actual}/${config[$REPODIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	i=10
	while [ $i -lt 20 ]
	do
		printf "\n" >> "${CONFDIR}InstalarT.conf";
		let i=$i+1
	done
	
	echo "$tail" >> "${CONFDIR}InstalarT.conf"     # le concateno el resto del archivo de conf viejo
else
	echo -e "GRUPO=01=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "ARRIDIR=${actual}/${config[$ARRIDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "DATASIZE=${config[$DATASIZE]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "RECHDIR=${actual}/${config[$RECHDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "BINDIR=${actual}/${config[$BINDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "MAEDIR=${actual}/${config[$MAEDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "LOGDIR=${actual}/${config[$LOGDIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "LOGEXT=${config[$LOGEXT]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "LOGSIZE=${config[$LOGSIZE]}=$str" >> "${CONFDIR}InstalarT.conf"
	echo -e "REPODIR=${actual}/${config[$REPODIR]}=$str" >> "${CONFDIR}InstalarT.conf"
	i=10
	while [ $i -lt 20 ]
	do
		printf "\n" >> "${CONFDIR}InstalarT.conf";
		let i=$i+1
	done
fi


# borro archivos temporales ####
rm -f "./inst/tmp/InstalarT.conf.tmp"

# muevo el log a LOGDIR
#mv -f "inst/tmp/InstalarT.log" "${config[$LOGDIR]}"

# fin
mostrarMensaje "I" "\nInstalacion finalizada\n\n"

# muevo LoguearT.sh
moverEjecutable $LoguearT "${NOMBRE_LoguearT}"

exit 0
